package chapter01.source03;

import java.awt.*;
import java.awt.event.*;
import java.text.SimpleDateFormat;
import java.util.*;
import java.io.*;
import javax.swing.undo.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.datatransfer.*;

@SuppressWarnings({"all"})
public class Notepad extends JFrame implements ActionListener, DocumentListener {   //菜单
    JFrame f;
    JMenu fileMenu, editMenu, formatMenu, viewMenu;
    //右键弹出菜单项
    JPopupMenu popupMenu;
    JMenuItem popupMenu_Undo, popupMenu_Cut, popupMenu_Copy, popupMenu_Paste, popupMenu_Delete, popupMenu_SelectAll,
            popupMenu_Search;
    //“文件”的菜单项
    JMenuItem fileMenu_New, fileMenu_Open, fileMenu_Save, fileMenu_SaveAs, fileMenu_PageSetUp,
             fileMenu_Exit, fileMenu_NewWindow;
    //“编辑”的菜单项
    JMenuItem editMenu_Undo, editMenu_Cut, editMenu_Copy, editMenu_Paste, editMenu_Delete, editMenu_Find,
            editMenu_FindNext, editMenu_Replace, editMenu_GoTo, editMenu_SelectAll, editMenu_TimeDate;
    //“格式”的菜单项
    JCheckBoxMenuItem formatMenu_LineWrap;
    JMenuItem formatMenu_Font;
    //“文本”编辑区域
    JTextArea editArea;
    //系统剪贴板
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    Clipboard clipBoard = toolkit.getSystemClipboard();
    protected UndoManager undo = new UndoManager();
    protected UndoableEditListener undoHandler = new UndoHandler();
    //其他变量
    String oldValue;//存放编辑区原来的内容，用于比较文本是否有改动
    boolean isNewFile = true;//是否新文件(未保存过的)
    File currentFile;//当前文件名

    //构造函数开始
    public Notepad() {
        super("Java记事本");
        //改变系统默认字体
        Font font = new Font("Dialog", Font.PLAIN, 14);
        java.util.Enumeration keys = UIManager.getDefaults().keys();
        while (keys.hasMoreElements()) {
            Object key = keys.nextElement();
            Object value = UIManager.get(key);
            if (value instanceof javax.swing.plaf.FontUIResource) {
                UIManager.put(key, font);
            }
        }
        //创建菜单条
        JMenuBar menuBar = new JMenuBar();
        //创建文件菜单及菜单项并注册事件监听
        fileMenu = new JMenu("文件(F)");
        fileMenu.setMnemonic('F');//设置快捷键ALT+F

        fileMenu_New = new JMenuItem("新建(N)");
        fileMenu_New.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_MASK));
        fileMenu_New.addActionListener(this);

        fileMenu_NewWindow = new JMenuItem(("新建窗口"));
        fileMenu_NewWindow.addActionListener(this);

        fileMenu_Open = new JMenuItem("打开(O)...");
        fileMenu_Open.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_MASK));
        fileMenu_Open.addActionListener(this);

        fileMenu_Save = new JMenuItem("保存(S)");
        fileMenu_Save.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_MASK));
        fileMenu_Save.addActionListener(this);

        fileMenu_SaveAs = new JMenuItem("另存为(A)");
        fileMenu_SaveAs.addActionListener(this);

        fileMenu_PageSetUp = new JMenuItem("页面设置(U)");
        fileMenu_PageSetUp.addActionListener(this);

        fileMenu_Exit = new JMenuItem("退出(X)");
        fileMenu_Exit.addActionListener(this);

        //创建编辑菜单及菜单项并添加事件监听
        editMenu = new JMenu("编辑(E)");
        editMenu.setMnemonic('E');//设置快捷键ALT+E
        //当选择编辑菜单时，设置剪切、复制、粘贴、删除等功能的可用性
        editMenu.addMenuListener(new MenuListener() {
            public void menuCanceled(MenuEvent e)//取消菜单时调用
            {
                checkMenuItemEnabled();//设置剪切、复制、粘贴、删除等功能的可用性
            }

            public void menuDeselected(MenuEvent e)//取消选择某个菜单时调用
            {
                checkMenuItemEnabled();
            }

            public void menuSelected(MenuEvent e)//选择某个菜单时调用
            {
                checkMenuItemEnabled();
            }
        });

        editMenu_Undo = new JMenuItem("撤销(U)");
        editMenu_Undo.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z, InputEvent.CTRL_MASK));
        editMenu_Undo.addActionListener(this);
        editMenu_Undo.setEnabled(false);

        editMenu_Cut = new JMenuItem("剪切(T)");
        editMenu_Cut.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X, InputEvent.CTRL_MASK));
        editMenu_Cut.addActionListener(this);

        editMenu_Copy = new JMenuItem("复制(C)");
        editMenu_Copy.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.CTRL_MASK));
        editMenu_Copy.addActionListener(this);

        editMenu_Paste = new JMenuItem("粘贴(P)");
        editMenu_Paste.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V, InputEvent.CTRL_MASK));
        editMenu_Paste.addActionListener(this);

        editMenu_Delete = new JMenuItem("删除(D)");
        editMenu_Delete.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0));
        editMenu_Delete.addActionListener(this);

        editMenu_Find = new JMenuItem("查找(F)...");
        editMenu_Find.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F, InputEvent.CTRL_MASK));
        editMenu_Find.addActionListener(this);

        editMenu_FindNext = new JMenuItem("查找下一个(N)");
        editMenu_FindNext.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F3, 0));
        editMenu_FindNext.addActionListener(this);

        editMenu_Replace = new JMenuItem("替换(R)...", 'R');
        editMenu_Replace.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_H, InputEvent.CTRL_MASK));
        editMenu_Replace.addActionListener(this);

        editMenu_GoTo = new JMenuItem("转到(G)...", 'G');
        editMenu_GoTo.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_G, InputEvent.CTRL_MASK));
        editMenu_GoTo.addActionListener(this);

        editMenu_SelectAll = new JMenuItem("全选", 'A');
        editMenu_SelectAll.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.CTRL_MASK));
        editMenu_SelectAll.addActionListener(this);

        editMenu_TimeDate = new JMenuItem("时间/日期(D)", 'D');
        editMenu_TimeDate.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F5, 0));
        editMenu_TimeDate.addActionListener(this);

        //创建格式菜单及菜单项并添加事件监听
        formatMenu = new JMenu("格式(O)");
        formatMenu.setMnemonic('O');//设置快捷键ALT+O

        formatMenu_LineWrap = new JCheckBoxMenuItem("自动换行(W)");
        formatMenu_LineWrap.setMnemonic('W');//设置快捷键ALT+W
        formatMenu_LineWrap.setState(true);//默认为true
        formatMenu_LineWrap.addActionListener(this);

        formatMenu_Font = new JMenuItem("字体(F)...");
        formatMenu_Font.addActionListener(this);


        //向菜单条添加"文件"菜单及菜单项
        menuBar.add(fileMenu);
        fileMenu.add(fileMenu_New);
        fileMenu.add(fileMenu_NewWindow);
        fileMenu.add(fileMenu_Open);
        fileMenu.add(fileMenu_Save);
        fileMenu.add(fileMenu_SaveAs);
        fileMenu.addSeparator();
        fileMenu.add(fileMenu_PageSetUp);
        fileMenu.addSeparator();
        fileMenu.add(fileMenu_Exit);

        //向菜单条添加"编辑"菜单及菜单项
        menuBar.add(editMenu);
        editMenu.add(editMenu_Undo);
        editMenu.add(editMenu_Cut);
        editMenu.add(editMenu_Copy);
        editMenu.add(editMenu_Paste);
        editMenu.add(editMenu_Delete);
        editMenu.add(editMenu_Find);
        editMenu.add(editMenu_FindNext);
        editMenu.add(editMenu_Replace);
        editMenu.add(editMenu_GoTo);
        editMenu.add(editMenu_SelectAll);
        editMenu.add(editMenu_TimeDate);

        //向菜单条添加"格式"菜单及菜单项
        menuBar.add(formatMenu);
        formatMenu.add(formatMenu_LineWrap);
        formatMenu.add(formatMenu_Font);


        //向窗口添加菜单条
        this.setJMenuBar(menuBar);

        //创建文本编辑区并添加滚动条
        editArea = new JTextArea(20, 50);
        JScrollPane scroller = new JScrollPane(editArea);
        scroller.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
        this.add(scroller, BorderLayout.CENTER);//向窗口添加文本编辑区
        editArea.setWrapStyleWord(true);//设置单词在一行不足容纳时换行
        editArea.setLineWrap(true);//设置文本编辑区自动换行默认为true,即会"自动换行"
        this.add(editArea, BorderLayout.CENTER);//向窗口添加文本编辑区

        editArea.getDocument().addUndoableEditListener(undoHandler);
        editArea.getDocument().addDocumentListener(this);

        //创建右键弹出菜单
        popupMenu = new JPopupMenu();
        popupMenu_Undo = new JMenuItem("撤销(U)");
        popupMenu_Cut = new JMenuItem("剪切(T)");
        popupMenu_Copy = new JMenuItem("复制(C)");
        popupMenu_Paste = new JMenuItem("粘帖(P)");
        popupMenu_Delete = new JMenuItem("删除(D)");
        popupMenu_SelectAll = new JMenuItem("全选(A)");
        popupMenu_Search = new JMenuItem("搜索");

        popupMenu_Undo.setEnabled(false);

        popupMenu.add(popupMenu_Undo);
        popupMenu.add(popupMenu_Cut);
        popupMenu.add(popupMenu_Copy);
        popupMenu.add(popupMenu_Paste);
        popupMenu.add(popupMenu_Delete);
        popupMenu.add(popupMenu_SelectAll);
        popupMenu.add(popupMenu_Search);

        popupMenu_Undo.addActionListener(this);
        popupMenu_Cut.addActionListener(this);
        popupMenu_Copy.addActionListener(this);
        popupMenu_Paste.addActionListener(this);
        popupMenu_Delete.addActionListener(this);
        popupMenu_SelectAll.addActionListener(this);
        popupMenu_Search.addActionListener(this);

        editArea.addMouseListener(new MouseAdapter() {
            public void mousePressed(MouseEvent e) {
                if (e.isPopupTrigger())//返回此鼠标事件是否为该平台的弹出菜单触发事件
                {
                    popupMenu.show(e.getComponent(), e.getX(), e.getY());//在点击出弹出弹出菜单
                }
                checkMenuItemEnabled();
                editArea.requestFocus();
            }

            public void mouseReleased(MouseEvent e) {
                if (e.isPopupTrigger())//返回此鼠标事件是否为该平台的弹出菜单触发事件
                {
                    popupMenu.show(e.getComponent(), e.getX(), e.getY());//在组件调用者的坐标空间中的位置 X、Y 显示弹出菜单
                }
                checkMenuItemEnabled();
                editArea.requestFocus();
            }
        });

        this.setLocation(100, 100);
        this.setSize(650, 550);
        this.setVisible(true);

        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                exitWindowChoose();
            }
        });
        oldValue = new String();
        checkMenuItemEnabled();
        editArea.requestFocus();
    }

    //设置菜单项的可用性：剪切，复制，粘帖，删除功能
    public void checkMenuItemEnabled() {
        String selectText = editArea.getSelectedText();
        if (selectText == null) {
            editMenu_Cut.setEnabled(false);
            popupMenu_Cut.setEnabled(false);
            editMenu_Copy.setEnabled(false);
            popupMenu_Copy.setEnabled(false);
            editMenu_Delete.setEnabled(false);
            popupMenu_Delete.setEnabled(false);
        } else {
            editMenu_Cut.setEnabled(true);
            popupMenu_Cut.setEnabled(true);
            editMenu_Copy.setEnabled(true);
            popupMenu_Copy.setEnabled(true);
            editMenu_Delete.setEnabled(true);
            popupMenu_Delete.setEnabled(true);
        }
        //粘帖功能可用性判断
        Transferable contents = clipBoard.getContents(this);
        if (contents == null) {
            editMenu_Paste.setEnabled(false);
            popupMenu_Paste.setEnabled(false);
        } else {
            editMenu_Paste.setEnabled(true);
            popupMenu_Paste.setEnabled(true);
        }
    }

    //关闭窗口时调用
    public void exitWindowChoose() {
        editArea.requestFocus();
        String currentValue = editArea.getText();
        if (currentValue.equals(oldValue)) {
            System.exit(0);
        } else {
            int exitChoose = JOptionPane.showConfirmDialog(this,
                    "您的文件尚未保存，是否保存？", "退出提示", JOptionPane.YES_NO_CANCEL_OPTION);
            if (exitChoose == JOptionPane.YES_OPTION) {   //boolean isSave=false;
                if (isNewFile) {
                    String str = null;
                    JFileChooser fileChooser = new JFileChooser();
                    fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                    fileChooser.setApproveButtonText("确定");
                    fileChooser.setDialogTitle("另存为");

                    int result = fileChooser.showSaveDialog(this);

                    if (result == JFileChooser.CANCEL_OPTION) {
                        return;
                    }

                    File saveFileName = fileChooser.getSelectedFile();

                    if (saveFileName == null || saveFileName.getName().equals("")) {
                        JOptionPane.showMessageDialog(this, "不合法的文件名",
                                "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                    } else {
                        try {
                            FileWriter fw = new FileWriter(saveFileName);
                            BufferedWriter bfw = new BufferedWriter(fw);
                            bfw.write(editArea.getText(), 0, editArea.getText().length());
                            bfw.flush();
                            fw.close();

                            isNewFile = false;
                            currentFile = saveFileName;
                            oldValue = editArea.getText();

                            this.setTitle(saveFileName.getName() + "  - 记事本");
                            //isSave=true;
                        } catch (IOException ioException) {
                        }
                    }
                } else {
                    try {
                        FileWriter fw = new FileWriter(currentFile);
                        BufferedWriter bfw = new BufferedWriter(fw);
                        bfw.write(editArea.getText(), 0, editArea.getText().length());
                        bfw.flush();
                        fw.close();
                        //isSave=true;
                    } catch (IOException ioException) {
                    }
                }
                System.exit(0);
            } else if (exitChoose == JOptionPane.NO_OPTION) {
                System.exit(0);
            } else if (exitChoose == JOptionPane.CANCEL_OPTION) {
                setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
            }
        }
    }

    //查找方法
    public void find() {
        final JDialog findDialog = new JDialog(this, "查找", false);//false时允许其他窗口同时处于激活状态(即无模式)
        Container con = findDialog.getContentPane();//返回此对话框的contentPane对象
        //与其他布局管理器不同的是，FlowLayout 布局管理器不限制它所管理组件的大小，而是允许它们有自己的最佳大小。
        con.setLayout(new FlowLayout(FlowLayout.LEFT));//左对齐
        JLabel findContentLabel = new JLabel("查找内容(N)：");
        final JTextField findText = new JTextField(15);
        JButton findNextButton = new JButton("查找下一个(F)：");
        final JCheckBox matchCheckBox = new JCheckBox("区分大小写(C)");
        final JCheckBox loopCheckBox = new JCheckBox("循环");
        ButtonGroup bGroup = new ButtonGroup();
        final JRadioButton upButton = new JRadioButton("向上(U)");
        final JRadioButton downButton = new JRadioButton("向下(U)");
        downButton.setSelected(true);
        bGroup.add(upButton);
        bGroup.add(downButton);
        JButton cancel = new JButton("取消");
        cancel.addActionListener(e -> findDialog.dispose());
        //"查找下一个"按钮监听
        findNextButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {   //"区分大小写(C)"的JCheckBox是否被选中
                int k = 0, m = 0;
                final String str1, str2, str3, str4, strA, strB;
                int g;
                str1 = editArea.getText();
                str2 = findText.getText();
                str3 = str1.toUpperCase();
                str4 = str2.toUpperCase();
                if (matchCheckBox.isSelected())//区分大小写
                {
                    strA = str1;//strA是editArea的文本内容
                    strB = str2;//strB是查找字符串
                } else//不区分大小写,此时把所选内容全部化成大写(或小写)，以便于查找
                {
                    strA = str3;
                    strB = str4;
                }
                if (upButton.isSelected()) {   //k=strA.lastIndexOf(strB,editArea.getCaretPosition()-1);
                    if (editArea.getSelectedText() == null) {
                        k = strA.lastIndexOf(strB, editArea.getCaretPosition() - 1);//k为从0开始数的索引,fromIndex从1开始数
                    } else {
//                        indexOf()方法从字符串的开头向后搜索字符串，而lastIndexOf()方法是从字符串的末尾向前搜索子字符串。
                        k = strA.lastIndexOf(strB, editArea.getCaretPosition() - findText.getText().length() - 1);
                    }

                    if (k > -1) {   //String strData=strA.subString(k,strB.getText().length()+1);
                        editArea.setCaretPosition(k);
                        editArea.select(k, k + strB.length());//select方法会把光标定到k + strB.length()
                    } else if (k == -1 && loopCheckBox.isSelected() && strA.contains(strB)) {
                        editArea.setCaretPosition(strA.length());
                        if (editArea.getSelectedText() == null) {
                            k = strA.lastIndexOf(strB, editArea.getCaretPosition() - 1);//k为从0开始数的索引,fromIndex从1开始数
                        } else {
//                        indexOf()方法从字符串的开头向后搜索字符串，而lastIndexOf()方法是从字符串的末尾向前搜索子字符串。
                            k = strA.lastIndexOf(strB, editArea.getCaretPosition() - findText.getText().length() - 1);
                        }
                        if (k > -1) {   //String strData=strA.subString(k,strB.getText().length()+1);
                            editArea.setCaretPosition(k);
                            editArea.select(k, k + strB.length());//select方法会把光标定到k + strB.length()
                        }
                    } else {
                        JOptionPane.showMessageDialog(null, "找不到您查找的内容！", "查找", JOptionPane.INFORMATION_MESSAGE);
                        editArea.setCaretPosition(0);
                    }

                } else if (downButton.isSelected()) {
                    if (editArea.getSelectedText() == null)
                        k = strA.indexOf(strB, editArea.getCaretPosition() - 1);
                    else
                        k = strA.indexOf(strB, editArea.getCaretPosition() - findText.getText().length() + 1);
                    if (k > -1) {   //String strData=strA.subString(k,strB.getText().length()+1);
                        editArea.setCaretPosition(k);
                        editArea.select(k, k + strB.length());
                    } else if (k == -1 && loopCheckBox.isSelected() && strA.contains(strB)) {
                        editArea.setCaretPosition(0);
                        if (editArea.getSelectedText() == null) {
                            k = strA.indexOf(strB, editArea.getCaretPosition() - 1);//k为从0开始数的索引,fromIndex从1开始数
                        } else {
//                        indexOf()方法从字符串的开头向后搜索字符串，而lastIndexOf()方法是从字符串的末尾向前搜索子字符串。
                            k = strA.indexOf(strB, editArea.getCaretPosition() - findText.getText().length() - 1);
                        }
                        if (k > -1) {   //String strData=strA.subString(k,strB.getText().length()+1);
                            editArea.setCaretPosition(k);
                            editArea.select(k, k + strB.length());//select方法会把光标定到k + strB.length()
                        }
                    } else {
                        JOptionPane.showMessageDialog(null, "找不到您查找的内容！", "查找", JOptionPane.INFORMATION_MESSAGE);
                        editArea.setCaretPosition(editArea.getText().length());
                    }
                }
            }
        });
        //创建"查找"对话框的界面
        JPanel panel1 = new JPanel();
        JPanel panel2 = new JPanel();
        JPanel panel3 = new JPanel();
        JPanel directionPanel = new JPanel();//directionPanel包含方向（向上、向下）
        directionPanel.setBorder(BorderFactory.createTitledBorder("方向"));
        //设置directionPanel组件的边框;
        //BorderFactory.createTitledBorder(String title)创建一个新标题边框，使用默认边框（浮雕化）、默认文本位置（位于顶线上）、默认调整 (leading) 以及由当前外观确定的默认字体和文本颜色，并指定了标题文本。
        directionPanel.add(downButton);
        directionPanel.add(upButton);
        panel1.setLayout(new GridLayout(2, 1));//panel1包含了查找下一个、取消两个按钮
        //setLayout(new GridLayout(2,1))设置布局方式：网络布局2行1列；
        //GridLayout 布局管理器总是忽略组件的最佳大小，而是根据提供的行和列进行平分。该布局管理的所有单元格的宽度和高度都是一样的。
        panel1.add(findNextButton);
        panel1.add(cancel);
        panel2.add(findContentLabel);//panel2包含查找内容和15格大小的文本输入框
        panel2.add(findText);
        panel2.add(panel1);//将panel1添加到panel2中
        panel3.add(matchCheckBox);//panel3包含区分大小写、循环、directionPanel
        panel3.add(loopCheckBox);
        panel3.add(directionPanel);
        con.add(panel2);
        con.add(panel3);
        findDialog.setSize(410, 180);
        findDialog.setResizable(false);//不可调整大小
        findDialog.setLocation(230, 280);
        findDialog.setVisible(true);
    }

    //替换方法
    public void replace() {
        final JDialog replaceDialog = new JDialog(this, "替换", false);//false时允许其他窗口同时处于激活状态(即无模式)
        Container con = replaceDialog.getContentPane();//返回此对话框的contentPane对象
        con.setLayout(new FlowLayout(FlowLayout.CENTER));
        JLabel findContentLabel = new JLabel("查找内容(N)：");
        final JTextField findText = new JTextField(15);
        JButton findNextButton = new JButton("查找下一个(F):");
        JLabel replaceLabel = new JLabel("替换为(P)：");
        final JTextField replaceText = new JTextField(15);
        JButton replaceButton = new JButton("替换(R)");
        JButton replaceAllButton = new JButton("全部替换(A)");
        JButton cancel = new JButton("取消");
        cancel.addActionListener(e -> replaceDialog.dispose());//lambda表达式
        final JCheckBox matchCheckBox = new JCheckBox("区分大小写(C)");
        ButtonGroup bGroup = new ButtonGroup();
        final JRadioButton upButton = new JRadioButton("向上(U)");
        final JRadioButton downButton = new JRadioButton("向下(U)");
        downButton.setSelected(true);
        bGroup.add(upButton);
        bGroup.add(downButton);

        //"查找下一个"按钮监听
        findNextButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {   //"区分大小写(C)"的JCheckBox是否被选中
                int k = 0, m = 0;
                final String str1, str2, str3, str4, strA, strB;
                str1 = editArea.getText();
                str2 = findText.getText();
                str3 = str1.toUpperCase();
                str4 = str2.toUpperCase();
                if (matchCheckBox.isSelected())//区分大小写
                {
                    strA = str1;
                    strB = str2;
                } else//不区分大小写,此时把所选内容全部化成大写(或小写)，以便于查找
                {
                    strA = str3;
                    strB = str4;
                }
                //向上被选中
                if (upButton.isSelected()) {   //k=strA.lastIndexOf(strB,editArea.getCaretPosition()-1);
                    if (editArea.getSelectedText() == null)
                        k = strA.lastIndexOf(strB, editArea.getCaretPosition() - 1);
                    else
                        k = strA.lastIndexOf(strB, editArea.getCaretPosition() - findText.getText().length() - 1);
                    if (k > -1) {   //String strData=strA.subString(k,strB.getText().length()+1);
                        editArea.setCaretPosition(k);
                        editArea.select(k, k + strB.length());
                    } else {
                        JOptionPane.showMessageDialog(null, "找不到您查找的内容！", "查找", JOptionPane.INFORMATION_MESSAGE);
                    }
                } else if (downButton.isSelected()) {
                    if (editArea.getSelectedText() == null)
                        k = strA.indexOf(strB, editArea.getCaretPosition() - 1);
                    else
                        k = strA.indexOf(strB, editArea.getCaretPosition() - findText.getText().length() + 1);
                    if (k > -1) {   //String strData=strA.subString(k,strB.getText().length()+1);
                        editArea.setCaretPosition(k);
                        editArea.select(k, k + strB.length());
                    } else {
                        JOptionPane.showMessageDialog(null, "找不到您查找的内容！", "查找", JOptionPane.INFORMATION_MESSAGE);
                    }
                }
            }
        });

        //"替换"按钮监听
        replaceButton.addActionListener(e -> {
            if (replaceText.getText().length() == 0 && editArea.getSelectedText() != null)
                editArea.replaceSelection("");
            if (replaceText.getText().length() > 0 && editArea.getSelectedText() != null)
                editArea.replaceSelection(replaceText.getText());
        });

        //"全部替换"按钮监听
        replaceAllButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                editArea.setCaretPosition(0);   //将光标放到编辑区开头
                int k = 0, m = 0, replaceCount = 0;
                if (findText.getText().length() == 0) {
                    JOptionPane.showMessageDialog(replaceDialog, "请填写查找内容!", "提示", JOptionPane.WARNING_MESSAGE);
                    findText.requestFocus(true);
                    return;
                }
                while (k > -1)//当文本中有内容被选中时(k>-1被选中)进行替换，否则不进行while循环
                {   //"区分大小写(C)"的JCheckBox是否被选中
                    final String str1, str2, str3, str4, strA, strB;
                    str1 = editArea.getText();
                    str2 = findText.getText();
                    str3 = str1.toUpperCase();
                    str4 = str2.toUpperCase();
                    if (matchCheckBox.isSelected())//区分大小写
                    {
                        strA = str1;
                        strB = str2;
                    } else//不区分大小写,此时把所选内容全部化成大写(或小写)，以便于查找
                    {
                        strA = str3;
                        strB = str4;
                    }
                    if (editArea.getSelectedText() == null)
                        k = strA.indexOf(strB, editArea.getCaretPosition() - 1);
                    else
                        k = strA.indexOf(strB, editArea.getCaretPosition() - findText.getText().length() + 1);
                    if (k > -1) {   //String strData=strA.subString(k,strB.getText().length()+1);
                        editArea.setCaretPosition(k);
                        editArea.select(k, k + strB.length());
                    } else {
                        if (replaceCount == 0) {
                            JOptionPane.showMessageDialog(replaceDialog, "找不到您查找的内容!", "记事本", JOptionPane.INFORMATION_MESSAGE);
                        } else {
                            JOptionPane.showMessageDialog(replaceDialog, "成功替换" + replaceCount + "个匹配内容!", "替换成功", JOptionPane.INFORMATION_MESSAGE);
                        }
                    }
//                    }
                    if (replaceText.getText().length() == 0 && editArea.getSelectedText() != null) {
                        editArea.replaceSelection("");
                        replaceCount++;
                    }

                    if (replaceText.getText().length() > 0 && editArea.getSelectedText() != null) {
                        editArea.replaceSelection(replaceText.getText());
                        replaceCount++;
                    }
                }
            }
        });

        //创建"替换"对话框的界面
        JPanel directionPanel = new JPanel();
        directionPanel.setBorder(BorderFactory.createTitledBorder("方向"));
        //设置directionPanel组件的边框;
        //BorderFactory.createTitledBorder(String title)创建一个新标题边框，使用默认边框（浮雕化）、默认文本位置（位于顶线上）、默认调整 (leading) 以及由当前外观确定的默认字体和文本颜色，并指定了标题文本。
        directionPanel.add(upButton);
        directionPanel.add(downButton);
        JPanel panel1 = new JPanel();
        JPanel panel2 = new JPanel();
        JPanel panel3 = new JPanel();
        JPanel panel4 = new JPanel();
        panel4.setLayout(new GridLayout(2, 1));
        panel1.add(findContentLabel);
        panel1.add(findText);
        panel1.add(findNextButton);
        panel4.add(replaceButton);
        panel4.add(replaceAllButton);
        panel2.add(replaceLabel);
        panel2.add(replaceText);
        panel2.add(panel4);
        panel3.add(matchCheckBox);
        panel3.add(directionPanel);
        panel3.add(cancel);
        con.add(panel1);
        con.add(panel2);
        con.add(panel3);
        replaceDialog.setSize(420, 220);
        replaceDialog.setResizable(false);//不可调整大小
        replaceDialog.setLocation(230, 280);
        replaceDialog.setVisible(true);
    }

    //"字体"方法
    public void font() {
        final JDialog fontDialog = new JDialog(this, "字体设置", false);
        Container con = fontDialog.getContentPane();
        con.setLayout(new FlowLayout(FlowLayout.LEFT));
        JLabel fontLabel = new JLabel("字体(F)：");
        fontLabel.setPreferredSize(new Dimension(100, 20));//构造一个Dimension，并将其初始化为指定宽度和高度
        JLabel styleLabel = new JLabel("字形(Y)：");
        styleLabel.setPreferredSize(new Dimension(100, 20));
        JLabel sizeLabel = new JLabel("大小(S)：");
        sizeLabel.setPreferredSize(new Dimension(100, 20));
        final JLabel sample = new JLabel("姚懿宸的记事本-YYC's Notepad");
        //sample.setHorizontalAlignment(SwingConstants.CENTER);
        final JTextField fontText = new JTextField(9);
        fontText.setPreferredSize(new Dimension(200, 20));
        final JTextField styleText = new JTextField(8);
        styleText.setPreferredSize(new Dimension(200, 20));
        final int style[] = {Font.PLAIN, Font.BOLD, Font.ITALIC, Font.BOLD + Font.ITALIC};
        final JTextField sizeText = new JTextField(5);
        sizeText.setPreferredSize(new Dimension(200, 20));
        JButton okButton = new JButton("确定");
        JButton cancel = new JButton("取消");
        cancel.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                fontDialog.dispose();
            }
        });
        Font currentFont = editArea.getFont();
        fontText.setText(currentFont.getFontName());
        fontText.selectAll();
        if (currentFont.getStyle() == Font.PLAIN)
            styleText.setText("常规");
        else if (currentFont.getStyle() == Font.BOLD)
            styleText.setText("粗体");
        else if (currentFont.getStyle() == Font.ITALIC)
            styleText.setText("斜体");
        else if (currentFont.getStyle() == (Font.BOLD + Font.ITALIC))
            styleText.setText("粗斜体");
        styleText.selectAll();
        String str = String.valueOf(currentFont.getSize());
        sizeText.setText(str);
        sizeText.selectAll();
        final JList fontList, styleList, sizeList;
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        final String fontName[] = ge.getAvailableFontFamilyNames();
        fontList = new JList(fontName);
        fontList.setFixedCellWidth(86);
        fontList.setFixedCellHeight(20);
        fontList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        final String fontStyle[] = {"常规", "粗体", "斜体", "粗斜体"};
        styleList = new JList(fontStyle);
        styleList.setFixedCellWidth(86);
        styleList.setFixedCellHeight(20);
        styleList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        if (currentFont.getStyle() == Font.PLAIN)
            styleList.setSelectedIndex(0);
        else if (currentFont.getStyle() == Font.BOLD)
            styleList.setSelectedIndex(1);
        else if (currentFont.getStyle() == Font.ITALIC)
            styleList.setSelectedIndex(2);
        else if (currentFont.getStyle() == (Font.BOLD + Font.ITALIC))
            styleList.setSelectedIndex(3);
        final String fontSize[] = {"8", "9", "10", "11", "12", "14", "16", "18", "20", "22", "24", "26", "28", "36", "48", "72"};
        sizeList = new JList(fontSize);
        sizeList.setFixedCellWidth(43);
        sizeList.setFixedCellHeight(20);
        sizeList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        fontList.addListSelectionListener(new ListSelectionListener() {
            public void valueChanged(ListSelectionEvent event) {
                fontText.setText(fontName[fontList.getSelectedIndex()]);
                fontText.selectAll();
                Font sampleFont1 = new Font(fontText.getText(), style[styleList.getSelectedIndex()], Integer.parseInt(sizeText.getText()));
                sample.setFont(sampleFont1);
            }
        });
        styleList.addListSelectionListener(new ListSelectionListener() {
            public void valueChanged(ListSelectionEvent event) {
                int s = style[styleList.getSelectedIndex()];
                styleText.setText(fontStyle[s]);
                styleText.selectAll();
                Font sampleFont2 = new Font(fontText.getText(), style[styleList.getSelectedIndex()], Integer.parseInt(sizeText.getText()));
                sample.setFont(sampleFont2);
            }
        });
        sizeList.addListSelectionListener(new ListSelectionListener() {
            public void valueChanged(ListSelectionEvent event) {
                sizeText.setText(fontSize[sizeList.getSelectedIndex()]);
                //sizeText.requestFocus();
                sizeText.selectAll();
                Font sampleFont3 = new Font(fontText.getText(), style[styleList.getSelectedIndex()], Integer.parseInt(sizeText.getText()));
                sample.setFont(sampleFont3);
            }
        });
        okButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                Font okFont = new Font(fontText.getText(), style[styleList.getSelectedIndex()], Integer.parseInt(sizeText.getText()));
                editArea.setFont(okFont);
                fontDialog.dispose();
            }
        });
        JPanel samplePanel = new JPanel();
        samplePanel.setBorder(BorderFactory.createTitledBorder("示例"));
        samplePanel.add(sample);
        JPanel panel1 = new JPanel();
        JPanel panel2 = new JPanel();
        JPanel panel3 = new JPanel();
        panel2.add(fontText);
        panel2.add(styleText);
        panel2.add(sizeText);
        panel2.add(okButton);
        panel3.add(new JScrollPane(fontList));//JList不支持直接滚动，所以要让JList作为JScrollPane的视口视图
        panel3.add(new JScrollPane(styleList));
        panel3.add(new JScrollPane(sizeList));
        panel3.add(cancel);
        con.add(panel1);
        con.add(panel2);
        con.add(panel3);
        con.add(samplePanel);
        fontDialog.setSize(350, 340);
        fontDialog.setLocation(200, 200);
        fontDialog.setResizable(false);
        fontDialog.setVisible(true);
    }

    //搜索方法
    public void sreach() {
        try {
            Runtime.getRuntime().exec(
                    "cmd   /c   start   http://baidu.com ");//跳转到www.baidu.com
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == fileMenu_New) {        //新建
            editArea.requestFocus();
            String currentValue = editArea.getText();
            boolean isTextChange = !currentValue.equals(oldValue);
            if (isTextChange) {
                int saveChoose = JOptionPane.showConfirmDialog(this,
                        "您的文件尚未保存，是否保存？", "提示", JOptionPane.YES_NO_CANCEL_OPTION);
                if (saveChoose == JOptionPane.YES_OPTION) {
                    String str;
                    JFileChooser fileChooser = new JFileChooser();
                    fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                    //fileChooser.setApproveButtonText("确定");
                    fileChooser.setDialogTitle("另存为");
                    int result = fileChooser.showSaveDialog(this);
                    if (result == JFileChooser.CANCEL_OPTION) {
                        return;
                    }
                    File saveFileName = fileChooser.getSelectedFile();
                    if (saveFileName == null || saveFileName.getName().equals("")) {
                        JOptionPane.showMessageDialog(this, "不合法的文件名",
                                "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                    } else {
                        try {
                            FileWriter fw = new FileWriter(saveFileName);
                            BufferedWriter bfw = new BufferedWriter(fw);
                            bfw.write(editArea.getText(), 0, editArea.getText().length());
                            bfw.flush();//刷新该流的缓冲
                            bfw.close();
                            isNewFile = false;
                            currentFile = saveFileName;
                            oldValue = editArea.getText();
                            this.setTitle(saveFileName.getName() + " - 记事本");
                        } catch (IOException ioException) {
                        }
                        editArea.replaceRange("", 0, editArea.getText().length());
                        this.setTitle("无标题 - 记事本");
                        isNewFile = true;
                        undo.discardAllEdits(); //撤消所有的"撤消"操作
                        editMenu_Undo.setEnabled(false);
                        oldValue = editArea.getText();
                    }
                } else if (saveChoose == JOptionPane.NO_OPTION) {
                    editArea.replaceRange("", 0, editArea.getText().length());
                    this.setTitle("无标题 - 记事本");
                    isNewFile = true;
                    undo.discardAllEdits(); //撤消所有的"撤消"操作
                    editMenu_Undo.setEnabled(false);
                    oldValue = editArea.getText();
                } else if (saveChoose == JOptionPane.CANCEL_OPTION) {
                    return;
                }
            } else {
                editArea.replaceRange("", 0, editArea.getText().length());
                this.setTitle("无标题 - 记事本");
                isNewFile = true;
                undo.discardAllEdits();//撤消所有的"撤消"操作
                editMenu_Undo.setEnabled(false);
                oldValue = editArea.getText();
            }
        }
        else if (e.getSource() == fileMenu_NewWindow) {  //新建窗口
            Notepad notepad2 = new Notepad();
            notepad2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

        }
        //打开
        else if (e.getSource() == fileMenu_Open) {
            editArea.requestFocus();
            String currentValue = editArea.getText();
            boolean isTextChange = (currentValue.equals(oldValue)) ? false : true;
            if (isTextChange) {
                int saveChoose = JOptionPane.showConfirmDialog(this,
                        "您的文件尚未保存，是否保存？", "提示", JOptionPane.YES_NO_CANCEL_OPTION);
                if (saveChoose == JOptionPane.YES_OPTION) {
                    String str = null;
                    JFileChooser fileChooser = new JFileChooser();
                    fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                    //fileChooser.setApproveButtonText("确定");
                    fileChooser.setDialogTitle("另存为");
                    int result = fileChooser.showSaveDialog(this);
                    if (result == JFileChooser.CANCEL_OPTION) {
                        return;
                    }
                    File saveFileName = fileChooser.getSelectedFile();
                    if (saveFileName == null || saveFileName.getName().equals("")) {
                        JOptionPane.showMessageDialog(this, "不合法的文件名",
                                "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                    } else {
                        try {
                            FileWriter fw = new FileWriter(saveFileName);
                            BufferedWriter bfw = new BufferedWriter(fw);
                            bfw.write(editArea.getText(), 0, editArea.getText().length());
                            bfw.flush();//刷新该流的缓冲
                            bfw.close();
                            isNewFile = false;
                            currentFile = saveFileName;
                            oldValue = editArea.getText();
                            this.setTitle(saveFileName.getName() + " - 记事本");
                        } catch (IOException ioException) {
                        }
                    }
                } else if (saveChoose == JOptionPane.NO_OPTION) {
                    String str = null;
                    JFileChooser fileChooser = new JFileChooser();
                    fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                    //fileChooser.setApproveButtonText("确定");
                    fileChooser.setDialogTitle("打开文件");
                    int result = fileChooser.showOpenDialog(this);
                    if (result == JFileChooser.CANCEL_OPTION) {
                        return;
                    }
                    File fileName = fileChooser.getSelectedFile();
                    if (fileName == null || fileName.getName().equals("")) {
                        JOptionPane.showMessageDialog(this, "不合法的文件名",
                                "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                    } else {
                        try {
                            FileReader fr = new FileReader(fileName);
                            BufferedReader bfr = new BufferedReader(fr);
                            editArea.setText("");
                            while ((str = bfr.readLine()) != null) {
                                editArea.append(str);
                            }
                            this.setTitle(fileName.getName() + " - 记事本");
                            fr.close();
                            isNewFile = false;
                            currentFile = fileName;
                            oldValue = editArea.getText();
                        } catch (IOException ioException) {
                        }
                    }
                } else {
                    return;
                }
            } else {
                String str = null;
                JFileChooser fileChooser = new JFileChooser();
                fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                //fileChooser.setApproveButtonText("确定");
                fileChooser.setDialogTitle("打开文件");
                int result = fileChooser.showOpenDialog(this);
                if (result == JFileChooser.CANCEL_OPTION) {
                    return;
                }
                File fileName = fileChooser.getSelectedFile();
                if (fileName == null || fileName.getName().equals("")) {
                    JOptionPane.showMessageDialog(this, "不合法的文件名",
                            "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                } else {
                    try {
                        FileReader fr = new FileReader(fileName);
                        BufferedReader bfr = new BufferedReader(fr);
                        editArea.setText("");
                        while ((str = bfr.readLine()) != null) {
                            editArea.append(str);
                        }
                        this.setTitle(fileName.getName() + " - 记事本");
                        fr.close();
                        isNewFile = false;
                        currentFile = fileName;
                        oldValue = editArea.getText();
                    } catch (IOException ioException) {
                    }
                }
            }
        }
        //保存
        else if (e.getSource() == fileMenu_Save) {
            editArea.requestFocus();
            if (isNewFile) {//是否有修改
                String str = null;
                JFileChooser fileChooser = new JFileChooser();
                fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                //fileChooser.setApproveButtonText("确定");
                fileChooser.setDialogTitle("保存");
                int result = fileChooser.showSaveDialog(this);
                if (result == JFileChooser.CANCEL_OPTION) {
                    return;
                }
                File saveFileName = fileChooser.getSelectedFile();
                if (saveFileName == null || saveFileName.getName().equals("")) {
                    JOptionPane.showMessageDialog(this, "不合法的文件名",
                            "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                } else {
                    try {
                        FileWriter fw = new FileWriter(saveFileName);
                        BufferedWriter bfw = new BufferedWriter(fw);
                        bfw.write(editArea.getText(), 0, editArea.getText().length());
                        bfw.flush();//刷新该流的缓冲
                        bfw.close();
                        isNewFile = false;
                        currentFile = saveFileName;
                        oldValue = editArea.getText();
                        this.setTitle(saveFileName.getName() + " - 记事本");
                    } catch (IOException ioException) {
                    }
                }
            } else {
                try {
                    FileWriter fw = new FileWriter(currentFile);
                    BufferedWriter bfw = new BufferedWriter(fw);
                    bfw.write(editArea.getText(), 0, editArea.getText().length());
                    bfw.flush();
                    fw.close();
                } catch (IOException ioException) {
                }
            }
        }
        //另存为
        else if (e.getSource() == fileMenu_SaveAs) {
            editArea.requestFocus();
            String str = null;
            JFileChooser fileChooser = new JFileChooser();
            fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
            //fileChooser.setApproveButtonText("确定");
            fileChooser.setDialogTitle("另存为");
            int result = fileChooser.showSaveDialog(this);
            if (result == JFileChooser.CANCEL_OPTION) {
                return;
            }
            File saveFileName = fileChooser.getSelectedFile();
            if (saveFileName == null || saveFileName.getName().equals("")) {
                JOptionPane.showMessageDialog(this, "不合法的文件名",
                        "不合法的文件名", JOptionPane.ERROR_MESSAGE);
            } else {
                try {
                    FileWriter fw = new FileWriter(saveFileName);
                    BufferedWriter bfw = new BufferedWriter(fw);
                    bfw.write(editArea.getText(), 0, editArea.getText().length());
                    bfw.flush();
                    fw.close();
                    oldValue = editArea.getText();
                    this.setTitle(saveFileName.getName() + "  - 记事本");
                } catch (IOException ioException) {
                }
            }
        }
        //页面设置
        else if (e.getSource() == fileMenu_PageSetUp) {
            editArea.requestFocus();
            Color initialcolor = Color.RED;
            Color color = JColorChooser.showDialog(this, "Select a color", initialcolor);
            editArea.setBackground(color);

        }
        //退出
        else if (e.getSource() == fileMenu_Exit) {
            int exitChoose = JOptionPane.showConfirmDialog(this, "确定要退出吗?", "退出提示", JOptionPane.OK_CANCEL_OPTION);
            if (exitChoose == JOptionPane.OK_OPTION) {
                System.exit(0);
            } else {
                return;
            }
        }
        //编辑
        else if(e.getSource()==editMenu)
        {
            checkMenuItemEnabled();
        }
        //撤销
        else if (e.getSource() == editMenu_Undo || e.getSource() == popupMenu_Undo) {
            editArea.requestFocus();
            if (undo.canUndo()) {
                try {
                    undo.undo();
                } catch (CannotUndoException ex) {
                    System.out.println("Unable to undo:" + ex);
                }
            }
            if (!undo.canUndo()) {
                editMenu_Undo.setEnabled(false);
            }
        }
        //剪切
        else if (e.getSource() == editMenu_Cut || e.getSource() == popupMenu_Cut) {
            editArea.requestFocus();
            String text = editArea.getSelectedText();
            StringSelection selection = new StringSelection(text);
            clipBoard.setContents(selection, null);
            editArea.replaceRange("", editArea.getSelectionStart(), editArea.getSelectionEnd());
            checkMenuItemEnabled();
        }
        //复制
        else if (e.getSource() == editMenu_Copy || e.getSource() == popupMenu_Copy) {
            editArea.requestFocus();
            String text = editArea.getSelectedText();
            StringSelection selection = new StringSelection(text);
            clipBoard.setContents(selection, null);
            checkMenuItemEnabled();
        }
        //粘帖
        else if (e.getSource() == editMenu_Paste || e.getSource() == popupMenu_Paste) {
            editArea.requestFocus();
            Transferable contents = clipBoard.getContents(this);
            if (contents == null) return;
            String text = "";
            try {
                text = (String) contents.getTransferData(DataFlavor.stringFlavor);
            } catch (Exception exception) {
            }
            editArea.replaceRange(text, editArea.getSelectionStart(), editArea.getSelectionEnd());
            checkMenuItemEnabled();
        }
        //删除
        else if (e.getSource() == editMenu_Delete || e.getSource() == popupMenu_Delete) {
            editArea.requestFocus();
            editArea.replaceRange("", editArea.getSelectionStart(), editArea.getSelectionEnd());
            checkMenuItemEnabled();
        }
        //查找
        else if (e.getSource() == editMenu_Find) {
            editArea.requestFocus();
            find();
        }
        //查找下一个
        else if (e.getSource() == editMenu_FindNext) {
            editArea.requestFocus();
            find();
        }
        //替换
        else if (e.getSource() == editMenu_Replace) {
            editArea.requestFocus();
            replace();
        }
        //转到
        else if (e.getSource() == editMenu_GoTo) {
            editArea.requestFocus();

            int lineNumber = 0;
            try {
                lineNumber = editArea.getLineOfOffset(editArea.getCaretPosition()) + 1;
                String tempStr = JOptionPane.showInputDialog(f, "行号(L):", "" + lineNumber);//默认填入当前光标所在行
                if (tempStr == null) {
                    return;
                }
                lineNumber = Integer.parseInt(tempStr);
                editArea.setCaretPosition(editArea.getLineStartOffset(lineNumber - 1));
            } catch (Exception e1) {
            }

        }
        //时间日期
        else if (e.getSource() == editMenu_TimeDate) {
            editArea.requestFocus();
            SimpleDateFormat currentDateTime=new SimpleDateFormat("HH:mm yyyy-MM-dd");//HH代表时，mm代表分，yyyy代表年，MM代表月，dd代表日
            editArea.insert(currentDateTime.format(new Date()),editArea.getCaretPosition());
            Calendar rightNow = Calendar.getInstance();
        }
        //全选
        else if (e.getSource() == editMenu_SelectAll || e.getSource() == popupMenu_SelectAll) {
            editArea.selectAll();
        }
        //自动换行(已在前面设置)
        else if (e.getSource() == formatMenu_LineWrap) {
            if (formatMenu_LineWrap.getState())
                editArea.setLineWrap(true);
            else
                editArea.setLineWrap(false);

        }
        //字体设置
        else if (e.getSource() == formatMenu_Font) {
            editArea.requestFocus();
            font();
        }

        //搜索
        else if (e.getSource() == popupMenu_Search) {
            sreach();
        }
    }

    public void removeUpdate(DocumentEvent e) {
        editMenu_Undo.setEnabled(true);
    }

    public void insertUpdate(DocumentEvent e) {
        editMenu_Undo.setEnabled(true);
    }

    public void changedUpdate(DocumentEvent e) {
        editMenu_Undo.setEnabled(true);
    }

    //实现接口UndoableEditListener的类UndoHandler(与撤销操作有关)
    class UndoHandler implements UndoableEditListener {
        public void undoableEditHappened(UndoableEditEvent uee) {
            undo.addEdit(uee.getEdit());
        }
    }

    //main函数开始
    public static void main(String args[]) {
        Notepad notepad = new Notepad();
        notepad.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//使用 System exit 方法退出应用程序
    }
}